{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "187\n",
      "145\n",
      "180\n",
      "22\n",
      "22\n",
      "26\n",
      "21\n",
      "23\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image\n",
    "import os\n",
    "import re\n",
    "import SimpleITK as sitk\n",
    "def normalization(data):\n",
    "    _range = np.max(data) - np.min(data)\n",
    "    return (data - np.min(data)) / (_range)\n",
    "SAVE_PATH = r\"/home/zhaosheng/paper2/online_code/cbamunet-pix2pix/results/smatunet_pixel\"\n",
    "ROOT = SAVE_PATH+\"//test_best/images/\"\n",
    "\n",
    "all_files  = os.listdir(ROOT)\n",
    "real_B_images = sorted([os.path.join(ROOT,file_name) for file_name in all_files if \"real_B\" in file_name])\n",
    "real_A_images = sorted([os.path.join(ROOT,file_name) for file_name in all_files if \"real_A\" in file_name])\n",
    "fake_B_images = sorted([os.path.join(ROOT,file_name) for file_name in all_files if \"fake_B\" in file_name])\n",
    "\n",
    "for i in range(len(real_A_images)):\n",
    "    real_A = np.array(Image.open(real_A_images[i]).convert(\"L\"))/255.\n",
    "    real_B = np.array(Image.open(real_B_images[i]).convert(\"L\"))/255.\n",
    "    fake_B = np.array(Image.open(fake_B_images[i]).convert(\"L\"))/255.\n",
    "    fake_B[fake_B<0.05] = real_B[fake_B<0.05] # 小数据量时暂时去除部分噪点\n",
    "    fake_B[fake_B>0.95] = real_B[fake_B>0.95]\n",
    "    file_name = real_B_images[i].split(\"/\")[-1].split(\"real\")[-2]\n",
    "    fake_B_HU = fake_B*(1800+1000)-1000\n",
    "    real_B_HU = real_B*(1800+1000)-1000\n",
    "    error = (fake_B_HU - real_B_HU)\n",
    "    os.makedirs(os.path.join(ROOT,\"numpy\"), exist_ok=True)\n",
    "    np.save(os.path.join(ROOT,\"numpy\",file_name+\"fake_B\"),fake_B_HU)\n",
    "    np.save(os.path.join(ROOT,\"numpy\",file_name+\"real_A\"),real_A)\n",
    "    np.save(os.path.join(ROOT,\"numpy\",file_name+\"real_B\"),real_B_HU)\n",
    "    np.save(os.path.join(ROOT,\"numpy\",file_name+\"error\"),error)\n",
    "\n",
    "fake_B_list_all = [os.path.join(ROOT,\"numpy\",_file) for _file in sorted(os.listdir(os.path.join(ROOT,\"numpy\"))) if \"fake_B\" in _file]\n",
    "real_B_list_all = [os.path.join(ROOT,\"numpy\",_file) for _file in sorted(os.listdir(os.path.join(ROOT,\"numpy\"))) if \"real_B\" in _file]\n",
    "real_A_list_all = [os.path.join(ROOT,\"numpy\",_file) for _file in sorted(os.listdir(os.path.join(ROOT,\"numpy\"))) if \"real_A\" in _file]\n",
    "error_list_all = [os.path.join(ROOT,\"numpy\",_file) for _file in sorted(os.listdir(os.path.join(ROOT,\"numpy\"))) if \"error\" in _file]\n",
    "\n",
    "import os\n",
    "os.getcwd()   #取得当前工作目录\n",
    "os.chdir(SAVE_PATH)\n",
    "#filename = \"001_ct\" # 001_ct 038_ct 052_ct\n",
    "for filename in [\"001_ct\" ,\"038_ct\", \"052_ct\",\"007_ct\"\\\n",
    "                ,\"009_ct\",\"010_ct\",\"050_ct\",\"051_ct\"]:\n",
    "    fake_B_list = [_file for _file in fake_B_list_all if filename in _file]\n",
    "    real_B_list = [_file for _file in real_B_list_all if filename in _file]\n",
    "    real_A_list = [_file for _file in real_A_list_all if filename in _file]\n",
    "    print(len(real_A_list))\n",
    "    error_list = [_file for _file in error_list_all if filename in _file]\n",
    "    real_A_array = []\n",
    "    for file in real_A_list:\n",
    "        array_ = np.load(file)\n",
    "        real_A_array.append(array_)\n",
    "    real_A_array = np.array(real_A_array)\n",
    "    real_A_array = np.transpose(real_A_array,(1,2,0))\n",
    "\n",
    "    fake_B_array = []\n",
    "    for file in fake_B_list:\n",
    "        array_ = np.load(file)\n",
    "        fake_B_array.append(array_)\n",
    "    fake_B_array = np.array(fake_B_array)\n",
    "    fake_B_array = np.transpose(fake_B_array,(1,2,0))\n",
    "\n",
    "    real_B_array = []\n",
    "    for file in real_B_list:\n",
    "        array_ = np.load(file)\n",
    "        real_B_array.append(array_)\n",
    "    real_B_array = np.array(real_B_array)\n",
    "    real_B_array = np.transpose(real_B_array,(1,2,0))\n",
    "\n",
    "    real_A_out = sitk.GetImageFromArray(real_A_array)\n",
    "    fake_B_out = sitk.GetImageFromArray(fake_B_array)\n",
    "    real_B_out = sitk.GetImageFromArray(real_B_array)\n",
    "    \n",
    "    sitk.WriteImage(real_A_out,filename+\"_real_A_out.nii\")\n",
    "    sitk.WriteImage(fake_B_out,filename+\"_fake_B_out.nii\")\n",
    "    sitk.WriteImage(real_B_out,filename+\"_real_B_out.nii\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unet_basic\n",
      "Mean MAE:111.80967265442642\n",
      "unet_pixel\n",
      "Mean MAE:106.12484743187001\n",
      "cbamunet_basic\n",
      "Mean MAE:112.66359430364471\n",
      "cbamunet_pixel\n",
      "Mean MAE:106.15099789939023\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from glob import glob\n",
    "import os\n",
    "from os import listdir\n",
    "from os.path import splitext\n",
    "import nibabel as nb\n",
    "import matplotlib.pyplot as plt\n",
    "import nibabel as nib\n",
    "import numpy as np\n",
    "from nibabel.viewers import OrthoSlicer3D\n",
    "import scipy.io as io\n",
    "import matplotlib.ticker as ticker\n",
    "import os\n",
    "os.getcwd()   #取得当前工作目录\n",
    "\n",
    "net_lists = [\"unet_basic\",\"unet_pixel\",\"cbamunet_basic\",\"cbamunet_pixel\"]#,\"resnet_basic\",\"resnet_pixel\"]\n",
    "for net in net_lists:\n",
    "    SAVE_PATH = os.path.join(r\"/home/zhaosheng/paper2/online_code/cbamunet-pix2pix/results/\",net)\n",
    "    print(net)\n",
    "    os.chdir(SAVE_PATH)\n",
    "\n",
    "\n",
    "    PLOT = False\n",
    "    plot_range = [0,999]\n",
    "\n",
    "    COLOR_BAR_FONT_SIZE = 6\n",
    "    all_mae = 0\n",
    "    nn = 0\n",
    "    for MODE in [\"sag\",\"cor\",\"axi\"]:        # 三个视图\n",
    "        for pat_num in [\"038\",\"052\",\"007\",\"010\",\"050\",\"051\"]: # 三个病例 \"001\",\"009\",\n",
    "            n = 110 # 第几层，可修改\n",
    "            fake_img = nib.load(\"./\"+pat_num+\"_ct_fake_B_out.nii\")\n",
    "            fake_ct_array = np.asanyarray(fake_img.dataobj)\n",
    "            fake_ct_array = np.array(fake_ct_array)#[:90,:,:]\n",
    "\n",
    "            real_img = nib.load(\"./\"+pat_num+\"_ct_real_B_out.nii\")\n",
    "            real_ct_array = np.asanyarray(real_img.dataobj)\n",
    "            real_ct_array = np.array(real_ct_array)#[:90,:,:]\n",
    "\n",
    "            assert fake_ct_array.shape == real_ct_array.shape\n",
    "            a,b,c = fake_ct_array.shape\n",
    "\n",
    "            # plt.colorbar(..., format=fmt)\n",
    "            if PLOT:\n",
    "                if MODE == \"sag\" or MODE == \"cor\":\n",
    "                    ax_aspect = b/a\n",
    "                else:\n",
    "                    ax_aspect = 1\n",
    "\n",
    "                func = lambda x,pos: \"{:g}HU\".format(x)\n",
    "                fmt = ticker.FuncFormatter(func)\n",
    "                plt.figure(dpi=400)\n",
    "\n",
    "                a1 = plt.subplot(1,3,1)\n",
    "\n",
    "                if MODE == \"sag\":\n",
    "                    fake_array = fake_ct_array[:,:,n]\n",
    "                    real_array = real_ct_array[:,:,n]\n",
    "                elif MODE == \"cor\":\n",
    "                    fake_array = fake_ct_array[:,n,:]\n",
    "                    real_array = real_ct_array[:,n,:]\n",
    "                else:\n",
    "                    fake_array = fake_ct_array[n,:,:]\n",
    "                    real_array = real_ct_array[n,:,:]\n",
    "\n",
    "                im =plt.imshow(fake_array,cmap='gray')\n",
    "                a1.set_aspect(ax_aspect)\n",
    "                plt.axis('off')\n",
    "                plt.rcParams['font.size'] = COLOR_BAR_FONT_SIZE\n",
    "                #plt.colorbar()\n",
    "                cb1 = plt.colorbar(im, fraction=0.03, pad=0.05, format=fmt)\n",
    "                tick_locator = ticker.MaxNLocator(nbins=4)  # colorbar上的刻度值个数\n",
    "                cb1.locator = tick_locator\n",
    "                cb1.update_ticks()\n",
    "\n",
    "\n",
    "                a2 = plt.subplot(1,3,2)\n",
    "                im2 =plt.imshow(real_array,cmap='gray')\n",
    "                a2.set_aspect(ax_aspect)\n",
    "                plt.axis('off')\n",
    "                plt.rcParams['font.size'] = COLOR_BAR_FONT_SIZE\n",
    "                cb1 = plt.colorbar(im2, fraction=0.03, pad=0.05, format=fmt)\n",
    "                tick_locator = ticker.MaxNLocator(nbins=4)  # colorbar上的刻度值个数\n",
    "                cb1.locator = tick_locator\n",
    "                cb1.update_ticks()\n",
    "\n",
    "\n",
    "                a3 = plt.subplot(1,3,3)\n",
    "                im3 =plt.imshow(fake_array-real_array,cmap='gray')\n",
    "                a3.set_aspect(ax_aspect)\n",
    "                plt.axis('off')\n",
    "                plt.rcParams['font.size'] = COLOR_BAR_FONT_SIZE\n",
    "                cb1 = plt.colorbar(im3, fraction=0.03, pad=0.05, format=fmt)\n",
    "                tick_locator = ticker.MaxNLocator(nbins=4)  # colorbar上的刻度值个数\n",
    "                cb1.locator = tick_locator\n",
    "                cb1.update_ticks()\n",
    "                plt.tight_layout()\n",
    "                #plt.savefig(\"./\"+pat_num+\"_\"+MODE+\".jpg\")\n",
    "                plt.show()\n",
    "            #print((fake_ct_array-real_ct_array).shape)\n",
    "            mae= np.abs((fake_ct_array-real_ct_array))[plot_range[0]:plot_range[1],30:-30,30:-30].mean()\n",
    "            #print(f\"P:{pat_num}\")\n",
    "            #print(f\"MAE : {mae}\")\n",
    "            #print(f\"ME : {(fake_ct_array-real_ct_array)[plot_range[0]:plot_range[1],:].mean()}\")\n",
    "            all_mae += mae\n",
    "            nn += 1\n",
    "    print(f\"Mean MAE:{all_mae/nn}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P:001\n",
      "MAE : 87.6304272074388\n",
      "P:038\n",
      "MAE : 72.15162866062377\n",
      "P:052\n",
      "MAE : 62.970755516833385\n",
      "P:007\n",
      "MAE : 45.437721075646195\n",
      "P:009\n",
      "MAE : 82.85721341981395\n",
      "P:010\n",
      "MAE : 80.33840173689666\n",
      "P:050\n",
      "MAE : 80.23172615400328\n",
      "P:051\n",
      "MAE : 67.29115049552432\n",
      "P:001\n",
      "MAE : 87.6304272074388\n",
      "P:038\n",
      "MAE : 72.15162866062377\n",
      "P:052\n",
      "MAE : 62.970755516833385\n",
      "P:007\n",
      "MAE : 45.437721075646195\n",
      "P:009\n",
      "MAE : 82.85721341981395\n",
      "P:010\n",
      "MAE : 80.33840173689666\n",
      "P:050\n",
      "MAE : 80.23172615400328\n",
      "P:051\n",
      "MAE : 67.29115049552432\n",
      "P:001\n",
      "MAE : 87.6304272074388\n",
      "P:038\n",
      "MAE : 72.15162866062377\n",
      "P:052\n",
      "MAE : 62.970755516833385\n",
      "P:007\n",
      "MAE : 45.437721075646195\n",
      "P:009\n",
      "MAE : 82.85721341981395\n",
      "P:010\n",
      "MAE : 80.33840173689666\n",
      "P:050\n",
      "MAE : 80.23172615400328\n",
      "P:051\n",
      "MAE : 67.29115049552432\n",
      "Mean ME:72.36362803334755\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from glob import glob\n",
    "import os\n",
    "from os import listdir\n",
    "from os.path import splitext\n",
    "import nibabel as nb\n",
    "import matplotlib.pyplot as plt\n",
    "import nibabel as nib\n",
    "import numpy as np\n",
    "from nibabel.viewers import OrthoSlicer3D\n",
    "import scipy.io as io\n",
    "import matplotlib.ticker as ticker\n",
    "import os\n",
    "os.getcwd()   #取得当前工作目录\n",
    "\n",
    "SAVE_PATH = r\"/home/zhaosheng/paper2/online_code/cbamunet-pix2pix/results/cbamunet_basic/\"\n",
    "os.chdir(SAVE_PATH)\n",
    "\n",
    "PLOT = False\n",
    "plot_range = [0,999]\n",
    "\n",
    "COLOR_BAR_FONT_SIZE = 6\n",
    "all_mae = 0\n",
    "nn = 0\n",
    "for MODE in [\"sag\",\"cor\",\"axi\"]:        # 三个视图\n",
    "    for pat_num in [\"001\",\"038\",\"052\",\"007\",\"009\",\"010\",\"050\",\"051\"]: # 三个病例\n",
    "        n = 110 # 第几层，可修改\n",
    "        fake_img = nib.load(\"./\"+pat_num+\"_ct_fake_B_out.nii\")\n",
    "        fake_ct_array = np.asanyarray(fake_img.dataobj)\n",
    "        fake_ct_array = np.array(fake_ct_array)#[:90,:,:]\n",
    "\n",
    "        real_img = nib.load(\"./\"+pat_num+\"_ct_real_B_out.nii\")\n",
    "        real_ct_array = np.asanyarray(real_img.dataobj)\n",
    "        real_ct_array = np.array(real_ct_array)#[:90,:,:]\n",
    "\n",
    "        assert fake_ct_array.shape == real_ct_array.shape\n",
    "        a,b,c = fake_ct_array.shape\n",
    "\n",
    "        # plt.colorbar(..., format=fmt)\n",
    "        if PLOT:\n",
    "            if MODE == \"sag\" or MODE == \"cor\":\n",
    "                ax_aspect = b/a\n",
    "            else:\n",
    "                ax_aspect = 1\n",
    "\n",
    "            func = lambda x,pos: \"{:g}HU\".format(x)\n",
    "            fmt = ticker.FuncFormatter(func)\n",
    "            plt.figure(dpi=400)\n",
    "\n",
    "            a1 = plt.subplot(1,3,1)\n",
    "\n",
    "            if MODE == \"sag\":\n",
    "                fake_array = fake_ct_array[:,:,n]\n",
    "                real_array = real_ct_array[:,:,n]\n",
    "            elif MODE == \"cor\":\n",
    "                fake_array = fake_ct_array[:,n,:]\n",
    "                real_array = real_ct_array[:,n,:]\n",
    "            else:\n",
    "                fake_array = fake_ct_array[n,:,:]\n",
    "                real_array = real_ct_array[n,:,:]\n",
    "\n",
    "            im =plt.imshow(fake_array,cmap='gray')\n",
    "            a1.set_aspect(ax_aspect)\n",
    "            plt.axis('off')\n",
    "            plt.rcParams['font.size'] = COLOR_BAR_FONT_SIZE\n",
    "            #plt.colorbar()\n",
    "            cb1 = plt.colorbar(im, fraction=0.03, pad=0.05, format=fmt)\n",
    "            tick_locator = ticker.MaxNLocator(nbins=4)  # colorbar上的刻度值个数\n",
    "            cb1.locator = tick_locator\n",
    "            cb1.update_ticks()\n",
    "\n",
    "\n",
    "            a2 = plt.subplot(1,3,2)\n",
    "            im2 =plt.imshow(real_array,cmap='gray')\n",
    "            a2.set_aspect(ax_aspect)\n",
    "            plt.axis('off')\n",
    "            plt.rcParams['font.size'] = COLOR_BAR_FONT_SIZE\n",
    "            cb1 = plt.colorbar(im2, fraction=0.03, pad=0.05, format=fmt)\n",
    "            tick_locator = ticker.MaxNLocator(nbins=4)  # colorbar上的刻度值个数\n",
    "            cb1.locator = tick_locator\n",
    "            cb1.update_ticks()\n",
    "\n",
    "\n",
    "            a3 = plt.subplot(1,3,3)\n",
    "            im3 =plt.imshow(fake_array-real_array,cmap='gray')\n",
    "            a3.set_aspect(ax_aspect)\n",
    "            plt.axis('off')\n",
    "            plt.rcParams['font.size'] = COLOR_BAR_FONT_SIZE\n",
    "            cb1 = plt.colorbar(im3, fraction=0.03, pad=0.05, format=fmt)\n",
    "            tick_locator = ticker.MaxNLocator(nbins=4)  # colorbar上的刻度值个数\n",
    "            cb1.locator = tick_locator\n",
    "            cb1.update_ticks()\n",
    "            plt.tight_layout()\n",
    "            #plt.savefig(\"./\"+pat_num+\"_\"+MODE+\".jpg\")\n",
    "            plt.show()\n",
    "        #print((fake_ct_array-real_ct_array).shape)\n",
    "        mae= np.abs((fake_ct_array-real_ct_array))[plot_range[0]:plot_range[1],:,:].mean()\n",
    "        print(f\"P:{pat_num}\")\n",
    "        print(f\"MAE : {mae}\")\n",
    "        #print(f\"ME : {(fake_ct_array-real_ct_array)[plot_range[0]:plot_range[1],:].mean()}\")\n",
    "        all_mae += mae\n",
    "        nn += 1\n",
    "print(f\"Mean ME:{all_mae/nn}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot Loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import re\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import os\n",
    "os.getcwd()   #取得当前工作目录\n",
    "\n",
    "SAVE_PATH = r\"/home/zhaosheng/paper2/online_code/cbamunet-pix2pix/\"\n",
    "os.chdir(SAVE_PATH)\n",
    "\n",
    "name_list = [\"unet_pixel\",\"cbamunet_pixel_style\",\"smatunet_pixel_style_batch_size_5\"]\n",
    "\n",
    "plt.figure(dpi=150)\n",
    "for name in name_list:\n",
    "    L1_loss = []\n",
    "    file = os.path.join(\"./checkpoints/\",name,\"loss_log.txt\")\n",
    "    file = open(file)\n",
    "    for line in file.readlines():\n",
    "        # 剔除开头部分\n",
    "        if \"epoch\" not in line :\n",
    "            continue\n",
    "\n",
    "        # 正则表达式分割\n",
    "        b= re.split(r\" +\",line)\n",
    "        if name == \"smatunet_pixel_style_batch_size_5\":\n",
    "            L1_loss.append(float(b[-8]))\n",
    "        else:\n",
    "            L1_loss.append(float(b[-6]))\n",
    "\n",
    "    plt.plot(L1_loss[:],label=name)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/zhaosheng/paper2/online_code/cbamunet-pix2pix/results/smatunet_pixel\n"
     ]
    }
   ],
   "source": [
    "!pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
